/**
 * 通用HTTP请求封装
 * 统一处理公共参数、签名、错误处理等
 */

// API响应解析器
export function parseApiResponse(data) {
  // 处理响应数据
  if (!data || typeof data !== 'object') {
    throw new Error('Invalid response format')
  }
  
  // 检查code字段
  if (data.code === 1) {
    // 成功时，尝试触发全局物品更新钩子（若响应包含item字段，支持数组或对象映射）
    try {
      const itemData = data?.data?.item
      if (typeof window !== 'undefined' && typeof window.__updateItemsFromResponse === 'function' && itemData) {
        let itemsArray = null
        if (Array.isArray(itemData)) {
          itemsArray = itemData
        } else if (typeof itemData === 'object') {
          itemsArray = Object.entries(itemData).map(([id, count]) => [Number(id), count])
        }
        if (Array.isArray(itemsArray) && itemsArray.length > 0) {
          window.__updateItemsFromResponse(itemsArray)
        }
      }
    } catch (e) {
      // 静默处理，不影响主流程
      console.warn('Items update hook failed:', e)
    }
    return data
  }
  
  // 错误处理 - 优先使用msg字段
  const errorMsg = data.msg || data.message || '请求失败'
  
  // 显示错误消息给用户
  showErrorMessage(errorMsg)
  // 特殊错误码处理
  handleSpecialErrorCodes(data.code)
  
  // 抛出错误以便调用方处理
  throw new Error(errorMsg)
}

// 显示错误消息 - 使用全局消息组件
function showErrorMessage(message) {
  // 优先使用全局消息组件（更舒适的提示）
  if (typeof window !== 'undefined' && typeof window.showMessage === 'function') {
    window.showMessage(message, 'error', 3000)
  } else if (typeof uni !== 'undefined' && uni.showToast) {
    // uni-app环境降级
    uni.showToast({
      title: message,
      icon: 'none',
      duration: 3000
    })
  } else if (typeof console !== 'undefined') {
    // 浏览器环境降级：使用console而不是alert
    console.warn('API Error:', message)
  }
}

// 处理特殊错误码
function handleSpecialErrorCodes(code) {
  if (code === 401) {
    // 未登录，清除本地存储并跳转到登录页
    localStorage.removeItem('yid')
    localStorage.removeItem('userId')
    localStorage.removeItem('currentRoleId')
    
    if (typeof uni !== 'undefined') {
      uni.reLaunch({
        url: '/pages/login/index'
      })
    } else {
      window.location.hash = '/pages/login/index'
    }
  }
}

// 生成签名
function generateSign(params, timestamp) {
  // 将参数按key排序
  const sortedKeys = Object.keys(params).sort()
  let signStr = ''
  
  sortedKeys.forEach(key => {
    if (params[key] !== '' && params[key] !== null && params[key] !== undefined) {
      signStr += `${key}=${params[key]}&`
    }
  })
  
  // 添加时间戳
  signStr += `timestamp=${timestamp}&`
  
  // 添加密钥（实际项目中应该从配置中获取）
  signStr += 'key=wujue_secret_key'
  
  // 简单的MD5签名（实际项目中建议使用更安全的签名算法）
  // 这里使用简单的字符串hash作为示例
  let hash = 0
  for (let i = 0; i < signStr.length; i++) {
    const char = signStr.charCodeAt(i)
    hash = ((hash << 5) - hash) + char
    hash = hash & hash // 转换为32位整数
  }
  
  return Math.abs(hash).toString(16)
}

// 获取公共参数
function getCommonParams() {
  const isDevEnv = (
    (typeof window !== 'undefined' && (window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1')) ||
    (typeof process !== 'undefined' && process.env && process.env.NODE_ENV !== 'production')
  )

  // 读取本地存储
  const storedYid = (typeof uni !== 'undefined' ? uni.getStorageSync('yid') : localStorage.getItem('yid')) || ''
  const storedRoleId = (typeof uni !== 'undefined' ? uni.getStorageSync('role_id') : localStorage.getItem('role_id')) || ''
  const storedDistrict = (typeof uni !== 'undefined' ? uni.getStorageSync('district') : localStorage.getItem('district')) || 'default'
  const storedChannel = (typeof uni !== 'undefined' ? uni.getStorageSync('channel') : localStorage.getItem('channel')) || 'web'

  // 在本地/测试环境下，若未设置则使用 is_test 作为默认测试凭证
  const yid = storedYid || (isDevEnv ? 'is_test' : '')
  const role_id = storedRoleId || (isDevEnv ? 'is_test' : '')

  return {
    yid,
    role_id,
    district: storedDistrict,
    channel: storedChannel,
    version: '1.0.0'
  }
}

// 通用请求方法
export function request(options) {
  return new Promise((resolve, reject) => {
    const timestamp = Date.now()
    const commonParams = getCommonParams()
    
    // 将公共参数和时间戳作为query参数
    const queryParams = {
      ...commonParams,
      timestamp
    }
    
    // 生成签名（包含业务数据和公共参数）
    const allParams = {
      ...commonParams,
      ...options.data,
      timestamp
    }
    const sign = generateSign(allParams, timestamp)
    queryParams.sign = sign
    
    // 构建query字符串
    const queryString = Object.keys(queryParams)
      .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(queryParams[key])}`)
      .join('&')
    
    // 构建完整URL：根据环境变量自动选择
    // 优先使用环境变量配置，如果没有则根据 NODE_ENV 判断
    let baseUrl = process.env.VUE_APP_API_BASE_URL
    
    // 如果没有配置环境变量，根据运行环境自动判断
    if (!baseUrl) {
      const isDevelopment = process.env.NODE_ENV === 'development'
      const isProduction = process.env.NODE_ENV === 'production'
      const hostname = typeof window !== 'undefined' ? window.location.hostname : ''
      
      if (isDevelopment || hostname === 'localhost' || hostname === '127.0.0.1') {
        // 开发环境：使用本地代理
        baseUrl = ''
      } else if (process.env.VUE_APP_ENV === 'test') {
        // 测试环境
        baseUrl = 'https://hhapi.cenkai123.com/wujue_cs_test'
      } else {
        // 生产环境
        baseUrl = 'https://hhapi.cenkai123.com/wujue_cs'
      }
    }
    
    // 构建URL：如果 baseUrl 为空（开发环境），使用相对路径走代理；否则使用绝对路径
    let url
    if (!baseUrl) {
      // 开发环境：使用相对路径，通过 vue.config.js 的代理转发
      // URL格式：/wujue_cs_test/xxx 或 /wujue_cs/xxx
      let path = options.url.startsWith('/') ? options.url : `/${options.url}`
      // 如果路径不以 /wujue_cs_test 或 /wujue_cs 开头，添加前缀
      if (!path.startsWith('/wujue_cs_test') && !path.startsWith('/wujue_cs')) {
        path = `/wujue_cs_test${path}`
      }
      url = path
    } else {
      // 生产/测试环境：使用绝对路径
      url = options.url.startsWith('/') 
        ? `${baseUrl}${options.url}` 
        : `${baseUrl}/${options.url}`
    }
    
    url += `?${queryString}`
    
    // 请求体只包含业务数据
    const requestData = options.data || {}
    
    // 构建fetch选项
    const fetchOptions = {
      method: options.method || 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Accept': 'application/json'
      }
    }
    
    // 只有非GET请求才添加body
    if (options.method !== 'GET') {
      fetchOptions.body = JSON.stringify(requestData)
    }
    
    // 使用fetch发送请求
    fetch(url, fetchOptions)
    .then(response => {
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`)
      }
      return response.json()
    })
    .then(data => {
      try {
        // 使用响应解析器处理响应
        const parsedData = parseApiResponse(data)
        resolve(parsedData)
      } catch (error) {
        reject(error)
      }
    })
    .catch(error => {
      console.error('Request failed:', error)
      reject(error)
    })
  })
}

// GET请求封装
export function get(url, params = {}) {
  return request({
    url,
    method: 'GET',
    data: params
  })
}

// POST请求封装
export function post(url, data = {}) {
  return request({
    url,
    method: 'POST',
    data
  })
}

// PUT请求封装
export function put(url, data = {}) {
  return request({
    url,
    method: 'PUT',
    data
  })
}

// DELETE请求封装
export function del(url, data = {}) {
  return request({
    url,
    method: 'DELETE',
    data
  })
}

export default {
  request,
  get,
  post,
  put,
  delete: del,
  parseApiResponse
}